home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / plotting / imagetoo / imagetl1.lha / Imagetool / HDF / df.c next >
Encoding:
C/C++ Source or Header  |  1990-09-20  |  46.3 KB  |  1,521 lines
  1. /*****************************************************************************
  2. * 
  3. *              NCSA HDF version 3.10
  4. *                July 1, 1990
  5. *
  6. * NCSA HDF Version 3.10 source code and documentation are in the public
  7. * domain.  Specifically, we give to the public domain all rights for future
  8. * licensing of the source code, all resale rights, and all publishing rights.
  9. * 
  10. * We ask, but do not require, that the following message be included in all
  11. * derived works:
  12. * 
  13. * Portions developed at the National Center for Supercomputing Applications at
  14. * the University of Illinois at Urbana-Champaign.
  15. * 
  16. * THE UNIVERSITY OF ILLINOIS GIVES NO WARRANTY, EXPRESSED OR IMPLIED, FOR THE
  17. * SOFTWARE AND/OR DOCUMENTATION PROVIDED, INCLUDING, WITHOUT LIMITATION,
  18. * WARRANTY OF MERCHANTABILITY AND WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE
  19. * 
  20. *****************************************************************************/
  21.  
  22. #ifdef RCSID
  23. static char RcsId[] = "@(#)$Revision: 3.4 $"
  24. #endif
  25. /*
  26. $Header: /pita/work/HDF/dev/RCS/src/df.c,v 3.4 90/06/29 10:07:31 mfolk beta $
  27. $Log:    df.c,v $
  28.  * Revision 3.4  90/06/29  10:07:31  mfolk
  29.  * *** empty log message ***
  30.  * 
  31.  * Revision 3.3  90/05/23  15:53:29  clow
  32.  * added MACRO "DF_OPENERR" to give uniform error open checking,
  33.  * especially for unbufferred I/O open
  34.  * 
  35. */
  36. /*-----------------------------------------------------------------------------
  37.  * File:    df.c
  38.  * Purpose: HDF low level file access
  39.  * Invokes: df.h
  40.  * Contents: 
  41.  *  DFImemcopy: copy bytes, on machines with no memcpy equivalents
  42.  *  DFopen: open HDF file
  43.  *  DFclose: close HDF file
  44.  *  DFIseedDDs: read data descriptors into memory
  45.  *  DFIcheck: check that dfile is a valid HDF file pointer
  46.  *  DFdescriptors: return a list of the data descriptors in the HDF file
  47.  *  DFnumber: count the number of occurrences of a given tag in the HDF file
  48.  *  DFsetfind: set up a search
  49.  *  DFfind: search for tag/ref combination
  50.  *  DFIfind: internal routine to actually perform search
  51.  *  DFIemptyDD: find an empty DD in the HDF file, or create one
  52.  *  DFaccess: set up a read/write on a data element
  53.  *  DFstart: set up a read/write on a data element
  54.  *  DFread: read a portion of a data element
  55.  *  DFseek: seek to new position within data element
  56.  *  DFwrite: write portion of a data element
  57.  *  DFupdate: write out updated DDs to HDF file
  58.  *  DFstat: provide status information about HDF file
  59.  *  DFgetelement: read an entire data element
  60.  *  DFputelement: write an entire data element
  61.  *  DFdup: create an additional descriptor for a data element
  62.  *  DFdel: delete a data element
  63.  *  DFnewref: Get an unused reference number
  64.  *  DFishdf: is this an HDF file?
  65.  *  DFerrno: return value of DFerror
  66.  *  DFIerr: close a file saving DFerror, return -1, for error handling.
  67.  * Remarks: These are the only routines which access HDF files directly
  68.  *---------------------------------------------------------------------------*/
  69.  
  70. #define DFMASTER
  71. #include "df.h"
  72.  
  73. #define CKMALLOC( x, ret) { if (!x) { DFerror = DFE_NOSPACE; return(ret); } }
  74.  
  75. #define CKSEEK(x,y,z, ret)  {  if (DF_SEEK( x,(long)y,z) <0) \
  76.                 {DFerror = DFE_SEEKERROR; return(ret); } }
  77.  
  78. #define CKSEEKEND(x,y,z, ret)   {  if (DF_SKEND( x,(long)y,z) <0) \
  79.                 {DFerror = DFE_SEEKERROR; return(ret); } }
  80.  
  81. #ifdef VMS
  82. #define CKREAD(x,y,z,f, ret)    { \
  83.                 int32 currfileposn; \
  84.                 currfileposn = DF_TELL(f); \
  85.                 if (DF_READ( (char*)x, (int)(y), (int)(z), (f))<0) \
  86.                 { DFerror = DFE_READERROR; return(ret); } \
  87.                 DF_SEEK(f, (long) (currfileposn + y*z), 0); \
  88.                 }
  89. #else /*VMS*/
  90. #define CKREAD(x,y,z,f, ret)    { \
  91.                 if (DF_READ( (char*)x, (int)(y), (int)(z), (f))<0) \
  92.                 { DFerror = DFE_READERROR; return(ret); } \
  93.                 }
  94. #endif /*VMS*/
  95.  
  96. #define CKWRITE(x,y,z,f, ret)   { if (DF_WRITE( (char*)x, (int)y, (int)z,f)<0) \
  97.                 {DFerror = DFE_WRITEERROR; return(ret); } }
  98.  
  99. /*
  100.  *  Important Internal Variables
  101.  */
  102. static DF *DFlist=NULL;        /* pointer to list of open DFs */
  103. static int DFinuse=0;        /* How many are currently in use */
  104. static uint16 DFmaxref;        /* which is the largest ref used? */
  105. static unsigned char *DFreflist=NULL; /* list of refs in use */
  106. static char patterns[] = {0x80, 0x40, 0x20, 0x10, 0x08,
  107.                        0x04, 0x02, 0x01};
  108.  
  109. #ifdef MAC
  110.  
  111. /*
  112. *  Macintosh file stubs for HDF
  113. *
  114. *  Implement a subset of the C unbuffered file I/O stubs in the
  115. *  Mac toolbox.
  116. */
  117.  
  118.  
  119. static int hdfc = 'Puf2', hdft = '_HDF';
  120.  
  121. mopen(name, flags)
  122.     char *name;
  123.     int flags;
  124. {
  125.     short volref,rn;
  126.  
  127.     GetVol(NULL,&volref);
  128.     
  129.     if (flags & O_CREAT)                     /* we need to create it */
  130.         create(name, volref, hdfc, hdft);
  131.     
  132.     if (0 != fsopen(name, volref, &rn))
  133.         return(-1);
  134.         
  135.     return(rn);
  136. }
  137.  
  138. mclose(rn)
  139.     int rn;
  140. {
  141.     return(FSClose(rn));
  142.  
  143. }
  144.  
  145. mread(rn, buf, n)
  146.     int rn,n;
  147.     char *buf;
  148. {
  149.     if (0 != FSRead( rn, &n, buf))
  150.         return(-1);
  151.         
  152.     return(n);
  153.  
  154. }
  155.  
  156. mwrite(rn, buf, n)
  157.     int rn,n;
  158.     char *buf;
  159. {
  160.     if (0 != FSWrite( rn, &n, buf))
  161.         return(-1);
  162.         
  163.     return(n);
  164. }
  165.  
  166. mlseek(rn, n, m)
  167.     int rn,n,m;
  168. {
  169.     switch(m) {
  170.         case 0:
  171.         default:
  172.             m = 1;
  173.             break;
  174.         case 1:
  175.             m = 3;
  176.             break;
  177.         case 2:
  178.             m = 2;
  179.             break;
  180.     }
  181.     
  182.     if (0 != SetFPos(rn, m, n))
  183.         return(-1);
  184.         
  185.     if (0 != GetFPos(rn, &n))
  186.         return(-1);
  187.         
  188.     return(n);
  189. }
  190. #endif /* MAC */
  191.  
  192. /*-----------------------------------------------------------------------------
  193.  * Name:    DFImemcopy
  194.  * Purpose: Copy bytes from one place to another
  195.  * Inputs:  from, to: source and destination for copy
  196.  *          length: number of bytes to copy
  197.  * Returns: 0 on success, -1 on failure with DFerror set
  198.  * Users:   HDF systems programmers, on machines without memcpy equivalents
  199.  * Remarks: assumes non-overlapping
  200.  *          Intended for machines on which memcppy etc. do not work
  201.  *---------------------------------------------------------------------------*/
  202.  
  203. DFImemcopy( from, to, length)
  204. char *from, *to;
  205. register int length;
  206. {
  207.     length++;
  208.     while (--length) *to++ = *from++;
  209.     return(0);
  210. }
  211.  
  212. /*-----------------------------------------------------------------------------
  213.  * Name:    DFopen
  214.  * Purpose: open DF file if it exists, else create it if write access
  215.  * Inputs:  name: name of file to open
  216.  *          access: DFACC_READ, DFACC_WRITE, DFACC_CREATE, DFACC_ALL
  217.  *          ndds: number of dds in a block
  218.  * Returns: DF ptr to open file on success, NULL on failure with DFerror set
  219.  * Invokes: DFIseedDDs 
  220.  * Users:   HDF programmers, many HDF user-level routines, utilities
  221.  * Remarks: Contains hooks for multiple DF files open simultaneously
  222.  *---------------------------------------------------------------------------*/
  223.  
  224. DF *DFopen( name, access, ndds )
  225. char *name;
  226. int access;
  227. int ndds;
  228. {
  229.     int created, i;             /* created is true if file is newly created */
  230.  
  231.                     /* error checking */
  232.     DFerror = DFE_NOERROR;
  233.  
  234.     if (!(*name)) {                             /* check name */
  235.         DFerror = DFE_BADNAME;
  236.         return(NULL);
  237.     }
  238.  
  239.     if ((access & (DFACC_ALL))!= access || access==0) {     /* check access */
  240.         DFerror = DFE_BADACC;
  241.         return(NULL); 
  242.     }
  243.     
  244.     if (DFinuse >= DF_MAXDFS) {    /* is DF table filled up? */
  245.         DFerror = DFE_TOOMANY; 
  246.         return(NULL);  
  247.     }
  248.     
  249.                 /* open file, set it up */
  250.         /* set up space for list of DFs */
  251.     if (!DFlist) {
  252.         DFlist = (DF *) DFIgetspace(DF_MAXDFS * sizeof(DF));
  253.         for (i=0; i<DF_MAXDFS; i++)
  254.             DFlist[i].type = 0;    /* mark free */
  255.     }
  256.  
  257.         /* locate unused slot in table */
  258.     for (i=0; i<DF_MAXDFS && DFlist[ i].type != 0; i++);
  259.  
  260.     if ( i>=DF_MAXDFS) {                            /* no free slot */
  261.         DFerror = DFE_TOOMANY;
  262.         return(NULL); 
  263.     }
  264.  
  265.     if (access == DFACC_CREATE) {
  266.         created = 1;
  267.         access = DFACC_WRITE;                   /* equivalent to write */
  268.     }
  269.     else created = 0;
  270.  
  271.         /* does an extra open just to check if file exists */
  272.     if (created || DF_OPENERR(DFlist[i].file = DF_OPEN(name, DF_RDACCESS))) {
  273.         if (access<2) {         /* file does not exist, check if read access */
  274.             DFerror = DFE_FNF;  /* file not found */
  275.             return(NULL);
  276.         }
  277. #ifndef MAC
  278.         close (DF_CREAT( name, 0666));  /* else create the file */
  279. #else /* MAC */
  280.         DF_CLOSE(DF_CREAT(name, 0666));
  281. #endif 
  282.         created=1;
  283.     }
  284.     else
  285.         DF_CLOSE(DFlist[i].file);   /* open successful, close it */
  286.  
  287.         /* open file with correct access mode */
  288.     if ( DF_OPENERR(DFlist[i].file = DF_OPEN( name, 
  289.         ((access>1) ? DF_WRACCESS : DF_RDACCESS ))) ) {
  290.         DFerror = DFE_BADOPEN;
  291.         return(NULL);
  292.     }
  293.  
  294.     if (created) {      /* Create a DDH and DD's for a new file */
  295.         DFdd dd;
  296.         DFddh ddh;
  297.     char magick[4];
  298.         int j;
  299.  
  300.     strncpy(magick, DF_MAGICK, 4); /* magick number */
  301.         CKWRITE( magick,4,1,DFlist[i].file, NULL);
  302.  
  303.         ddh.next=0;                         /* only one DDH */
  304.         if (ndds<=0) DFlist[i].defdds = DF_DEFAULTDDS;  
  305.         else DFlist[i].defdds = ndds;       /* set up number of DDs in block */
  306.         ddh.dds = DFlist[i].defdds;
  307.         dd.tag=DFTAG_NULL;              /* set up empty DD */
  308.         dd.ref=0;                       /* offset, length don't care */
  309.  
  310. #ifdef DF_STRUCTOK                      /* okay to write structures? */
  311.         CKWRITE( &ddh, sizeof(DFddh), 1, DFlist[i].file, NULL); /* write it */
  312. #else /*DF_STRUCTOK*/
  313.         {
  314.             register char *p;
  315.             /* copy structure into buffer, write it out */
  316.             p = DFtbuf;
  317.             INT16WRITE( p, ddh.dds);    /* header */
  318.             INT32WRITE( p, ddh.next);
  319.             CKWRITE( DFtbuf, 6, 1, DFlist[i].file, NULL);   /* 6=header size */
  320.         }
  321. #endif /*DF_STRUCTOK*/
  322.  
  323.         for (j=0; j<ddh.dds; j++) {             /* write out DDs */
  324. #ifdef DF_STRUCTOK
  325.             CKWRITE( &dd, sizeof(DFdd),1, DFlist[i].file, NULL);
  326. #else /*DF_STRUCTOK*/
  327.             {
  328.                 register char *p;
  329.                 p = DFtbuf;
  330.                 UINT16WRITE( p, dd.tag);
  331.                 UINT16WRITE( p, dd.ref);
  332.                 INT32WRITE( p, dd.offset);
  333.                 INT32WRITE( p, dd.length);
  334.                 CKWRITE( DFtbuf, 12, 1, DFlist[i].file, NULL); /* 12=DD size */
  335.             }
  336. #endif /*DF_STRUCTOK*/
  337.         }
  338.     }
  339.     else {            /* if file already exists */
  340.          char magick[4];
  341.  
  342.         CKREAD( magick, 4, 1, DFlist[i].file, NULL); /* check magick number */
  343.         if ( strncmp(magick,DF_MAGICK,4)) {
  344.             DFerror = DFE_NOTDFFILE;
  345.             DF_CLOSE(DFlist[i].file);
  346.             return(NULL);
  347.         }
  348.     }
  349.  
  350.     /* store status information in struct */
  351.     if (ndds<=0) DFlist[i].defdds = DF_DEFAULTDDS;  
  352.     else DFlist[i].defdds = ndds;
  353.     DFlist[i].access=access;
  354.     DFlist[i].list = NULL;
  355.     DFlist[i].changed=0;
  356.     DFlist[i].last_tag= 0;
  357.     DFlist[i].last_ref= 0;
  358.     DFlist[i].type=1;
  359.     DFlist[i].up_access=0;
  360.     DFlist[i].up_dd = NULL;
  361.  
  362.             /* read DDs and store the information in internal structure */
  363.     if (DFIseedDDs( &DFlist[i]) <0) return(NULL);
  364.  
  365.     if (created) {                  /* create MT if new file */
  366.         DFdd *dd;
  367.         dd = &(DFlist[i].list->next->dd[0]);    /* first dd is in 2nd dle */
  368.         dd->tag = DFTAG_MT;
  369.         dd->ref = DF_MT;
  370.         dd->offset = 0;
  371.         dd->length = 0;
  372.     }
  373.     DFinuse++;                      /* no of DF slots in use */
  374.     return( &DFlist[i]);            /* DF file pointer */
  375. }
  376.  
  377.  
  378. /*-----------------------------------------------------------------------------
  379.  * Name:    DFclose
  380.  * Purpose: Write out updated DDs, close DF file
  381.  * Inputs:  dfile: pointer to open DF file
  382.  * Returns: 0 on success, -1 on failure with DFerror set
  383.  * Invokes: DFIcheck
  384.  * Users:   HDF programmers, many HDF user-level routines, utilities
  385.  *---------------------------------------------------------------------------*/
  386.  
  387. int DFclose( dfile)
  388. DF *dfile;
  389. {
  390.     DFdle *prev, *current;          /* DLEs being written out */
  391.     int i;
  392.  
  393.     DFerror = DFE_NOERROR;
  394.  
  395.     if ( DFIcheck(dfile))           /* is dfile a valid pointer? */
  396.         return(-1);
  397.  
  398.     if (dfile->type!=1) {           /* 0 is a closed file  or unused slot */
  399.         DFerror= DFE_NOTOPEN;
  400.         return(-1);
  401.     }
  402.  
  403.     prev=dfile->list;               /* start of DLE list */
  404.  
  405.     while (current=prev->next) {        /* for all DLEs */
  406.         if (dfile->changed) {           /* if file modified, write it out */
  407.                 /* current DD should be written at location prev->ddh.next */
  408.             CKSEEK( dfile->file, (long) prev->ddh.next,0, -1);
  409.             if (current->ddh.dds) {     /* if any DDs to write out */
  410. #ifdef DF_STRUCTOK
  411.                 CKWRITE( ¤t->ddh, sizeof(DFddh)+
  412.                     current->ddh.dds*sizeof(DFdd), 1, dfile->file, -1);
  413. #else /*DF_STRUCTOK*/
  414.                 {           /* write out dd struct elements */
  415.                     register  char *p;
  416.                     p = DFtbuf;
  417.                     INT16WRITE( p, current->ddh.dds);
  418.                     INT32WRITE( p, current->ddh.next);
  419.                     for (i=0; i<current->ddh.dds; i++) {
  420.                         UINT16WRITE( p, current->dd[i].tag);
  421.                         UINT16WRITE( p, current->dd[i].ref);
  422.                         INT32WRITE( p, current->dd[i].offset);
  423.                         INT32WRITE( p, current->dd[i].length);
  424.                     }
  425.                     CKWRITE( DFtbuf, 6+i*12, 1, dfile->file, -1);
  426.                             /* 6=size of DDH, 12=size of DD */
  427.                 }
  428. #endif /*DF_STRUCTOK*/
  429.             }
  430.         }
  431.         DFIfreespace((char*)prev);
  432.         prev=current;
  433.     }
  434.     DFIfreespace((char*)prev); /* get rid of the last one */
  435.  
  436.     if ( (DF_CLOSE( dfile->file)) !=0) {
  437.         DFerror = DFE_CANTCLOSE;
  438.         return(-1);
  439.     }
  440.  
  441.                     /* reset structure values */
  442.     dfile->last_ref= 0;
  443.     dfile->last_tag= 0;
  444.     dfile->type=0;
  445.     dfile->access=0;
  446.     dfile->file= 0;
  447.     dfile->list= (DFdle *) 0L;
  448.     DFinuse--;
  449.     return(0);
  450. }   
  451.  
  452.  
  453. /*-----------------------------------------------------------------------------
  454.  * Name:    DFIseedDDs
  455.  * Purpose: read DDs in file into memory
  456.  * Inputs:  dfile: pointer to open DF file
  457.  * Returns: 0 on success, -1 on failure with DFerror set
  458.  * Users:   HDF systems programmers, DFopen
  459.  *---------------------------------------------------------------------------*/
  460.  
  461. int DFIseedDDs(dfile)
  462. DF *dfile;
  463. {
  464.     DFdle *list;
  465.     DFddh ddh;
  466.     int i,n;                        /* n = no. of DDs in block */
  467.     
  468.     DFerror = DFE_NOERROR;
  469.  
  470.     if (dfile->list) {
  471.         DFerror = DFE_SEEDTWICE;    /* ### NOTE: Internal error! */
  472.         return(-1);
  473.     }
  474.     
  475.     dfile->list= (DFdle *) DFIgetspace(sizeof(DFdle));
  476.     /* includes one DD - unused */
  477.     CKMALLOC( dfile->list, -1);
  478.  
  479.     list=dfile->list;
  480.     list->next=NULL;                /* No other lists (yet) */
  481.     list->ddh.next= (int32)4L;      /* next is at 4 in file */
  482.     list->ddh.dds= -1;              /* flag so this is not written */
  483.  
  484.     DFmaxref = 0;                   /* largest ref found till now is 0 */
  485.  
  486.     while (list->ddh.next) {        /* while more headers to read */
  487.         CKSEEK( dfile->file, list->ddh.next, 0, -1);
  488.  
  489.                             /* read headers */
  490. #ifdef DF_STRUCTOK
  491.         CKREAD( &ddh, sizeof(DFddh), 1, dfile->file, -1);
  492. #else /*DF_STRUCTOK*/
  493.         {
  494.             register  char *p;
  495.             p = DFtbuf;
  496.             CKREAD( DFtbuf, 6, 1, dfile->file, -1);     /* 6 = size of header */
  497.             INT16READ( p, ddh.dds);
  498.             INT32READ( p, ddh.next);
  499.         }
  500. #endif /*DF_STRUCTOK*/
  501.         n   =ddh.dds;
  502.  
  503.     /* read in DDs */
  504.         list->next= (DFdle *)
  505.         DFIgetspace((unsigned)
  506.             (sizeof(DFdle)+ (n-1)* sizeof(DFdd)));
  507.                 /* note space for 1 DD included in DLE */
  508.         CKMALLOC( list->next, -1);
  509.         list=list->next;
  510.         list->next=NULL;
  511.     
  512.         DFmovmem((char*)&ddh, (char*)&(list->ddh),
  513.          sizeof(DFddh) ); /* Copy ddh */
  514.  
  515.         if (n) {
  516. #ifdef DF_STRUCTOK
  517.             CKREAD( &list->dd[0], sizeof(DFdd), n, dfile->file, -1);
  518.         /* load DD's */
  519. #else /*DF_STRUCTOK*/
  520.             {
  521.                 register  char *p;
  522.                 p = DFtbuf;
  523.                 CKREAD( DFtbuf, n*12, 1, dfile->file, -1);  /* 12=size of DD */
  524.                 for (i=0; i<n; i++) {
  525.                     UINT16READ( p, list->dd[i].tag);
  526.                     UINT16READ( p, list->dd[i].ref);
  527.                     INT32READ( p, list->dd[i].offset);
  528.                     INT32READ( p, list->dd[i].length);
  529.                 }
  530.             }
  531. #endif /*DF_STRUCTOK*/
  532.         }
  533.                 /* Remember highest ref found - ignore MTs */
  534.         for (i=0; i<n; i++)
  535.             if ((list->dd[i].ref > DFmaxref) && (list->dd[i].tag != DFTAG_MT))
  536.                                      DFmaxref = list->dd[i].ref;
  537.     }
  538.     return(0);
  539. }
  540.  
  541.  
  542. /*-----------------------------------------------------------------------------
  543.  * Name:    DFIcheck
  544.  * Purpose: check if dfile argument represents a valid DF file
  545.  * Inputs:  dfile: pointer to open DF file
  546.  * Returns: 0 on success, -1 on failure with DFerror set
  547.  * Users:   HDF systems programmers, several routines in this file
  548.  *---------------------------------------------------------------------------*/
  549.  
  550. int DFIcheck( dfile)
  551. DF *dfile;
  552. {
  553.     DFerror = DFE_NOERROR;
  554.     
  555.     if (!dfile) {
  556.         DFerror = DFE_DFNULL;
  557.         return(-1);
  558.         }
  559.  
  560.     if ((dfile->access & DFACC_ALL) != dfile->access)
  561.         DFerror = DFE_BADACC;
  562.  
  563.     if ((dfile->type >1) || (dfile->type <-1))
  564.         DFerror = DFE_ILLTYPE;
  565.  
  566.     if (!dfile->list)
  567.         DFerror= DFE_BADDDLIST;
  568.  
  569.     if (DFerror)
  570.         return(-1);
  571.     else
  572.         return(0);
  573.  
  574. }
  575.  
  576.  
  577. /*-----------------------------------------------------------------------------
  578.  * Name:    DFdescriptors
  579.  * Purpose: return a list of all the DDs in the file
  580.  * Inputs:  dfile: pointer to open DF file
  581.  *          ptr: pointer to space for the list of DDs
  582.  *          begin, num: the list starts at DD numbered begin, and contains
  583.  *              a maximum of num entries
  584.  * Returns: number of DDs returned in the list
  585.  * Invokes: DFIcheck
  586.  * Users:   HDF programmers, other routines and utilities
  587.  *---------------------------------------------------------------------------*/
  588.  
  589. int DFdescriptors(dfile, ptr, begin, num)
  590. DF *dfile;
  591. DFdesc ptr[];
  592. int begin, num;
  593. {
  594.     DFdle *DLEp;
  595.     int i,ddnum=0;
  596.  
  597.     if ( DFIcheck(dfile))
  598.         return(-1);
  599.     
  600.     if (begin<0) begin = 0;
  601.     if (num<0) num = 0;
  602.     ddnum = 0;
  603.     for (DLEp=dfile->list; DLEp; DLEp=DLEp->next)
  604.         for (i=0; i<DLEp->ddh.dds; i++, ddnum++)
  605.             if (ddnum>=begin) {
  606.                 if (ddnum<begin+num) {
  607.                     ptr[ddnum-begin] = DLEp->dd[i];
  608.                 }
  609.                 else
  610.                     return(num);
  611.             }
  612.     return(ddnum-begin);
  613. }
  614.  
  615.  
  616. /*-----------------------------------------------------------------------------
  617.  * Name:    DFnumber
  618.  * Purpose: return the number of occurrences of the given tag in the HDF file
  619.  * Inputs:  dfile: pointer to open DF file
  620.  *          tag: tag to count occurrences of
  621.  * Returns: number of occurrences of tag in file, -1 on error with DFerror set
  622.  *          if tag is DFTAG_WILDCARD, count occurrences of all tags
  623.  * Invokes: DFIcheck
  624.  * Users:   HDF programmers, other routines and utilities
  625.  *---------------------------------------------------------------------------*/
  626.  
  627. int DFnumber(dfile, tag)
  628. DF *dfile;
  629. uint16 tag;
  630. {
  631.     DFdle *DLEp;
  632.     int i, ntag=0;
  633.  
  634.     if ( DFIcheck(dfile))
  635.         return(-1);
  636.     
  637.     for (DLEp=dfile->list; DLEp; DLEp=DLEp->next)
  638.         if (tag==DFTAG_WILDCARD) ntag += DLEp->ddh.dds;
  639.         else {
  640.             for (i=0; i<DLEp->ddh.dds; i++)
  641.                 if (DLEp->dd[i].tag == tag) ntag++;
  642.         }
  643.  
  644.     return(ntag);
  645. }
  646.  
  647.  
  648. /*-----------------------------------------------------------------------------
  649.  * Name:    DFsetfind
  650.  * Purpose: set up parameters for a wildcard find
  651.  * Inputs:  dfile: pointer to open DF file
  652.  *          tag, ref: tag and ref of element to search for, 0 is wildcard
  653.  * Returns: 0 on success, -1 on failure
  654.  * Invokes: DFIcheck
  655.  * Users:   HDF programmers, several utilities
  656.  *---------------------------------------------------------------------------*/
  657.  
  658. int DFsetfind( dfile, tag, ref)
  659. DF *dfile;
  660. uint16 tag,ref;
  661. {
  662.  
  663.     if ( DFIcheck(dfile))
  664.         return(-1);
  665.     
  666.         /* remember tag, ref for subsequent searches */
  667.     dfile->last_tag=tag;
  668.     dfile->last_ref=ref;
  669.     dfile->last_dle=NULL;           /* flag value: nothing found so far */
  670.  
  671.     return(0);
  672. }
  673.     
  674.  
  675. /*-----------------------------------------------------------------------------
  676.  * Name:    DFfind
  677.  * Purpose: perform wildcard searches - sets up parameters, calls DFIfind
  678.  * Inputs:  dfile: pointer to open DF file
  679.  *          ptr: ptr to put in DD when found
  680.  * Returns: 0 on success, -1 on failure
  681.  *          if success, DD matching specification is copied to *ptr
  682.  * Invokes: DFIcheck, DFIfind
  683.  * Users:   HDF programmers, several utilities
  684.  *---------------------------------------------------------------------------*/
  685.  
  686. int DFfind(dfile, ptr)
  687. DF *dfile;
  688. DFdesc *ptr;
  689. {
  690.     DFdle *cDLEp;
  691.     int cdd;
  692.     uint16 tag, ref, ltag,lref;
  693.     int isfirst=1;
  694.  
  695.     if ( DFIcheck(dfile))
  696.         return(-1);
  697.  
  698.     DFerror = DFE_NOERROR;
  699.  
  700.     tag = dfile->last_tag;          /* tag, ref being searched for */
  701.     ref = dfile->last_ref;
  702.  
  703.     if (dfile->last_dle) {          /* something found previously */
  704.         isfirst = 0;
  705.         ltag= dfile->last_dle->dd[ dfile->last_dd ].tag;    /* prev tag, ref */
  706.         lref= dfile->last_dle->dd[ dfile->last_dd ].ref;
  707.     } else {
  708.     ltag = lref = 0;
  709.     }
  710.  
  711.     if ((tag!=DFTAG_NULL) &&        /* empty DDs are invisible on finds */
  712.         !DFIfind( dfile, tag, ref, isfirst, ltag, lref, &cDLEp, &cdd)) {
  713.         *ptr = cDLEp->dd[cdd];      /* if found, copy dd to ptr */
  714.         dfile->last_dd = cdd;       /* set last_dle and last_dd to DD found */
  715.         dfile->last_dle= cDLEp;
  716.         return(0);
  717.     } else {
  718.         DFerror = DFE_NOMATCH;
  719.         ptr->tag = 0;
  720.         ptr->ref = 0;
  721.         return(-1);
  722.     }
  723. }
  724.         
  725.  
  726. /*-----------------------------------------------------------------------------
  727.  * Name:    DFIfind
  728.  * Purpose: perform wildcard searches
  729.  * Inputs:  dfile: pointer to open DF file
  730.  *          tag, ref: tag, ref (possibly wildcard) being searched for
  731.  *          isfirst: 1 if first call to DFIfind for this tag/ref, else 0
  732.  *          ltag, lref: last tag and ref returned for this search,
  733.  *              don't care if isfirst set
  734.  *          cDLEp, cddp: pointers to DLE and DD number to return matched DD in
  735.  * Returns: 0 on success, -1 on failure
  736.  *          if success, cDLEp and cddp are set to point to matched DD
  737.  * Users:   HDF system programmers, DFfind, HDF utilities, many routines
  738.  * Remarks: The searching algorithm is a little complex.  It returns entries
  739.  *          in the sorting order of refs, then tags.  Even after a candidate
  740.  *          is found, searching continues till best candidate found.  Best way
  741.  *          to check if conditions: work it out independently for yourself!
  742.  *---------------------------------------------------------------------------*/
  743.  
  744. int DFIfind( dfile, tag, ref, isfirst, ltag, lref, cDLEp, cddp)
  745. DF *dfile;
  746. DFdle **cDLEp;
  747. int *cddp;
  748. int isfirst;                            /* 1 if no prev search, 0 otherwise */
  749. uint16 tag, ref, ltag, lref;
  750. {
  751.     DFdle *DLEp;
  752.     int i, found=0;
  753.     uint16 ctag=0, cref=0, wtag,wref; /* ctag, cref: tag, ref found so far */
  754.                                       /* wtag, wref: tag, ref being checked */
  755.  
  756.     DLEp=dfile->list;               /* start of DLE list */
  757.  
  758.     if (tag && ref) {               /* No wildcards */
  759.         if (isfirst) {              /* if not already found */
  760.             while (DLEp) {          /* go through list */
  761.                 for (i=0; i<DLEp->ddh.dds; i++) {       /* for all DDs */
  762.                     if (DLEp->dd[i].tag==tag &&
  763.                             DLEp->dd[i].ref==ref)
  764.                         {*cDLEp=DLEp; *cddp=i; return(0);}
  765.                     }
  766.                 DLEp=DLEp->next;
  767.                 }
  768.             }
  769.         }
  770.     else if (tag && !ref)           /* wildcard ref */
  771.         while (DLEp) {
  772.             for (i=0; i<DLEp->ddh.dds; i++) {
  773.                 wtag=DLEp->dd[i].tag;
  774.                 wref=DLEp->dd[i].ref;
  775.         /* condition = tag match, better than found so far (if any),
  776.             follows what was returned last time (if any) */
  777.                 if ( (wtag==tag) && (!found || (wref<cref)) &&
  778.                     (isfirst || (wref>lref)))
  779.                     { ctag=wtag; cref=wref; *cDLEp=DLEp; *cddp=i;found=1;}
  780.                 }
  781.             DLEp=DLEp->next;
  782.             }
  783.     else if (!tag && ref)           /* wildcard tag */
  784.         while (DLEp) {
  785.             for (i=0; i<DLEp->ddh.dds; i++) {
  786.                 wtag=DLEp->dd[i].tag;
  787.                 wref=DLEp->dd[i].ref;
  788.                 if ((wref==ref) && (isfirst || (wtag>ltag)) &&
  789.                     (!found || (wtag<ctag)) )
  790.                     { ctag=wtag; cref=wref; *cDLEp=DLEp; *cddp=i;found=1;}
  791.                 }
  792.             DLEp=DLEp->next;
  793.             }
  794.     else if (!tag && !ref)          /* wildcard tag & ref */
  795.         while (DLEp) {
  796.             for (i=0; i<DLEp->ddh.dds; i++) {
  797.                 wtag=DLEp->dd[i].tag;
  798.                 wref=DLEp->dd[i].ref;
  799.                 if ((isfirst || (wref>lref) || (wref==lref && wtag>ltag)) &&
  800.                     (!found || (wref<cref) || (wref==cref && wtag<ctag)) &&
  801.                     (wtag!=DFTAG_NULL))         /* empty DDs are invisible */
  802.                     { ctag=wtag; cref=wref; *cDLEp=DLEp; *cddp=i;found=1;}
  803.                 }
  804.             DLEp=DLEp->next;
  805.             }
  806.     return(found-1);            /* 0 or -1 */
  807. }
  808.  
  809.  
  810. /*-----------------------------------------------------------------------------
  811.  * Name:    DFIemptyDD
  812.  * Purpose: find an empty DD to use, or create a block of DDs if necessary
  813.  * Inputs:  dfile: pointer to open DF file
  814.  * Returns: pointer to an empty DD
  815.  * Invokes: DFIfind
  816.  * Users:   HDF system programmers, DFaccess, DFdup
  817.  *---------------------------------------------------------------------------*/
  818.  
  819. DFdd *DFIemptyDD(dfile)
  820. DF *dfile;
  821. {
  822.     DFdle *cDLEp;
  823.     int cdd;
  824.  
  825.     if (!DFIfind( dfile, DFTAG_NULL, DFREF_WILDCARD, 1, 0, 0, &cDLEp, &cdd))
  826.         return(&(cDLEp->dd[cdd]));      /* there is an empty DD */
  827.  
  828.     else {          /* add new DDH block */
  829.         int32 fpos;
  830.         DFdle *p, *dle;
  831.         DFddh ddh;
  832.         DFdd dd;
  833.         int j;
  834.  
  835.         CKSEEKEND( dfile->file, (long) 0, 2, NULL); /* go to end of df */
  836.         fpos= (int32) DF_TELL(dfile->file);
  837.         ddh.dds= dfile->defdds;             /* Initialize ddh */
  838.         ddh.next= 0;
  839.         dd.tag=DFTAG_NULL;                  /* and all DD's */
  840.         dd.ref=0;
  841. #ifdef DF_STRUCTOK
  842.         CKWRITE( &ddh, sizeof(DFddh), 1, dfile->file, NULL);
  843. #else /*DF_STRUCTOK*/
  844.         {
  845.             register  char *p;
  846.             p = DFtbuf;
  847.             INT16WRITE( p, ddh.dds);
  848.             INT32WRITE( p, ddh.next);
  849.             CKWRITE( DFtbuf, 6, 1, dfile->file, NULL);  /* 6 = size of header */
  850.         }
  851. #endif /*DF_STRUCTOK*/
  852.         for (j=0; j<ddh.dds; j++) {
  853. #ifdef DF_STRUCTOK
  854.             CKWRITE( &dd, sizeof(DFdd),1, dfile->file, NULL);
  855. #else /*DF_STRUCTOK*/
  856.             {
  857.                 register  char *p;
  858.                 p = DFtbuf;
  859.                 UINT16WRITE( p, dd.tag);
  860.                 UINT16WRITE( p, dd.tag);
  861.                 INT32WRITE( p, dd.offset);
  862.                 INT32WRITE( p, dd.length);
  863.                 CKWRITE( DFtbuf, 12, 1, dfile->file, NULL); /* 12=size of dd */
  864.             }
  865. #endif /*DF_STRUCTOK*/
  866.         }
  867.  
  868.         p=dfile->list;                      /* find end of list */
  869.         while (p->next) p= p->next;
  870.  
  871.         p->ddh.next=fpos;                   /* new dd goes at end of file */
  872.         dle=(DFdle *)
  873.         DFIgetspace((unsigned)
  874.             (sizeof(DFdle)+(ddh.dds-1)*sizeof(DFdd)));
  875.                             /* one dd included in dle */
  876.         CKMALLOC(dle, NULL);
  877.         p->next=dle;                        /* insert dle at end of list */
  878.         dle->next=NULL;
  879.         DFmovmem((char*)&ddh, (char*)&dle->ddh,sizeof(DFddh));
  880.         for (j=0; j<ddh.dds; j++)
  881.             DFmovmem( (char*)&dd, (char*)&dle->dd[j], sizeof(DFdd));
  882.         return(&(dle->dd[0]));
  883.     }
  884. #ifdef PC
  885.     return(NULL);           /* dummy, for return value checking */
  886. #endif /*PC*/
  887. }
  888.  
  889.  
  890. /*-----------------------------------------------------------------------------
  891.  * Name:    DFaccess
  892.  * Purpose: set up read/write access to a data element
  893.  * Inputs:  dfile: pointer to open DF file
  894.  *          tag, ref: id of element
  895.  *          access: "r", "w", "a" (append)
  896.  * Returns: 0 on success, -1 on failure
  897.  * Invokes: DFIcheck, DFIfind, DFIemptyDD
  898.  * Users:   HDF programmers, utilities, DFgetelement, DFputelement
  899.  * Remarks: if "a", data element will be copied to end of file, since it
  900.  *          cannot be extended in place if it is in the middle of the file
  901.  *---------------------------------------------------------------------------*/
  902.  
  903. int DFaccess(dfile, tag, ref, access)
  904. DF *dfile;
  905. uint16 tag, ref;
  906. char *access;
  907. {
  908.     DFdle *cDLEp;
  909.     int cdd;
  910.      char *storage=NULL;        /* for copying data if append access */
  911.     char accmode;
  912.     
  913.     DFerror = DFE_NOERROR;
  914.  
  915.     if (DFIcheck(dfile) )
  916.         return( -1);
  917.  
  918.     if (!tag) {
  919.         DFerror = DFE_BADTAG;
  920.         return(-1);
  921.     }
  922.     if (!ref) {
  923.         DFerror = DFE_BADREF;
  924.         return(-1);
  925.     }
  926.             /* set up and check access modes */
  927.     accmode = *access;
  928.     switch (accmode) {
  929.         case 'r':   dfile->up_access = DFACC_READ;  break;
  930.         case 'a':
  931.         case 'w':   dfile->up_access = DFACC_WRITE; break;
  932.         default:    DFerror = DFE_BADACC;   return(-1); 
  933.     }
  934.     if ((dfile->up_access & dfile->access) != dfile->up_access) {
  935.         DFerror = DFE_BADACC;
  936.         return(-1);
  937.     }
  938.                     
  939.                 /* Find DD of element to be updated */
  940.     if (!DFIfind( dfile, tag, ref, 1, 0 , 0, &cDLEp, &cdd))
  941.         dfile->up_dd = &(cDLEp->dd[cdd]);   /* DD of element to be updated */
  942.  
  943.     else {              /* No such DD */
  944.         if (accmode=='r') {
  945.             DFerror = DFE_NOMATCH; 
  946.             return(-1);
  947.         }
  948.         accmode = 'w';          /* append is really write if no current data */
  949.         dfile->up_dd = DFIemptyDD(dfile);       /* find an empty DD to use */
  950.         if (!dfile->up_dd) return(-1);
  951.         dfile->up_dd->tag = tag;                    /* fill in DD block */
  952.         dfile->up_dd->ref = ref;
  953.         dfile->up_dd->length = 0;
  954.     }
  955.  
  956.     if (accmode!='w') {        /*for read, DFaccess positions fp at element */
  957.                                 /* for append also, we need to read element */
  958.         CKSEEK(dfile->file, (long) dfile->up_dd->offset, 0, -1);
  959.         }
  960.     else dfile->up_dd->length = 0;  /* throws away any existing data */
  961.  
  962.     if (accmode!='r') {
  963.         dfile->changed = 1;         /* if write/append, file modified */
  964.  
  965.         if ((accmode=='a') && (dfile->up_dd->length)) {
  966.                     /* allocate storage to read current data */
  967.                 storage = (char*)DFIgetspace((unsigned)(dfile->up_dd->length));
  968.                 CKMALLOC( storage, -1 );
  969.                 CKREAD( storage, dfile->up_dd->length, 1, dfile->file, -1);
  970.         }
  971.  
  972.         CKSEEKEND( dfile->file, (long) 0, 2, -1);   /* go to end of df */
  973.             /* find the offset of the end of file */
  974.         dfile->up_dd->offset = (int32) DF_TELL(dfile->file);
  975.  
  976.         if ((accmode=='a') && dfile->up_dd->length) {   /* copy old data */
  977.             CKWRITE( storage, dfile->up_dd->length, 1, dfile->file, -1);
  978.                 /* note this leaves fp positioned correctly for write */
  979.         }
  980.         if (storage) DFIfreespace(storage);
  981.     }
  982.  
  983.     if (DFmaxref < ref) DFmaxref = ref;                 /* note ref is used */
  984.     if (DFreflist) DFreflist[ref/8] |= patterns[ref%8]; /* set ref'th bit */
  985.  
  986.     return(0);
  987. }
  988.  
  989.  
  990. /*-----------------------------------------------------------------------------
  991.  * Name:    DFstart
  992.  * Purpose: set up read/write access to a data element - alternate to DFaccess
  993.  * Inputs:  dfile: pointer to open DF file
  994.  *          tag, ref: id of element
  995.  *          access: "r", "w", "a" (append)
  996.  * Returns: 0 on success, -1 on failure
  997.  * Invokes: DFaccess
  998.  * Users:   Accidental/old-time users, intending to use DFaccess
  999.  * Remarks: none
  1000.  *---------------------------------------------------------------------------*/
  1001.  
  1002. int DFstart(dfile, tag, ref, access)
  1003. DF *dfile;
  1004. uint16 tag, ref;
  1005. char *access;
  1006. {
  1007.  
  1008.     return(DFaccess(dfile, tag, ref, access));
  1009. }
  1010.         
  1011.  
  1012. /*-----------------------------------------------------------------------------
  1013.  * Name:    DFread
  1014.  * Purpose: read bytes from DF file (part of element specified by DFaccess)
  1015.  * Inputs:  dfile: pointer to open DF file
  1016.  *          ptr: pointer to space to read data into
  1017.  *          len: number of bytes to read
  1018.  * Returns: number of bytes read on success, -1 on failure
  1019.  * Invokes: DFIcheck
  1020.  * Users:   HDF programmers, DFgetelement
  1021.  *---------------------------------------------------------------------------*/
  1022.  
  1023. int32 DFread( dfile, ptr, len)
  1024. DF *dfile;
  1025. char *ptr;
  1026. int32 len;
  1027. {
  1028.     int32 maxlen;
  1029. #ifdef VMS
  1030.     int32 totalread;
  1031.     int32 readsize;
  1032. #endif /*VMS*/
  1033.  
  1034.     DFerror = DFE_NOERROR;
  1035.  
  1036.     if (DFIcheck(dfile) )
  1037.         return( (int32) -1);
  1038.  
  1039.     if (!dfile->up_dd) {
  1040.         DFerror = DFE_BADCALL;
  1041.         return((int32) -1);
  1042.     }
  1043.  
  1044.     if (!(dfile->up_access & DFACC_READ)) {
  1045.         DFerror = DFE_BADACC;
  1046.         return((int32) -1);
  1047.     }
  1048.  
  1049.     if (!ptr) {
  1050.         DFerror = DFE_BADPTR;
  1051.         return((int32) -1);
  1052.     }
  1053.  
  1054.     maxlen = dfile->up_dd->length -
  1055.                 ((int32) DF_TELL(dfile->file) - dfile->up_dd->offset);
  1056.     if (len>maxlen) len = maxlen;
  1057.     if (len<0) {            /* will also catch reads from beyond element */
  1058.         DFerror = DFE_BADLEN;
  1059.         return(-1);
  1060.     }
  1061.  
  1062. #ifdef VMS
  1063.     totalread = 0;
  1064.     while (totalread<len) {
  1065.         readsize = len - totalread;
  1066.         if (readsize>512) readsize = 512;
  1067.         CKREAD( &ptr[totalread], (int)readsize, 1, dfile->file, -1); 
  1068.         totalread += readsize;
  1069.     }
  1070.         
  1071. #else /*VMS*/
  1072.     if (len) {      /* NOTE: cast to (int) will limit to 64K on 16 bit m/cs */
  1073.         CKREAD( ptr, (int) len, 1, dfile->file, -1); 
  1074.     }
  1075. #endif /*VMS*/
  1076.  
  1077.     return(len);
  1078. }
  1079.  
  1080.  
  1081. /*-----------------------------------------------------------------------------
  1082.  * Name:    DFseek
  1083.  * Purpose: seek to a position, within element specified by DFaccess
  1084.  * Inputs:  dfile: pointer to open DF file
  1085.  *          offset: offset from beginning of element
  1086.  * Returns: offset of actual position seek'ed to from beginning of element
  1087.  * Invokes: DFIcheck
  1088.  * Users:   HDF programmers
  1089.  *---------------------------------------------------------------------------*/
  1090.  
  1091. int32 DFseek( dfile, offset)
  1092. DF *dfile;
  1093. int32 offset;
  1094. {
  1095.     
  1096.     DFerror = DFE_NOERROR;
  1097.  
  1098.     if (DFIcheck(dfile) )
  1099.         return( -1);
  1100.  
  1101.     if (!dfile->up_dd) {
  1102.         DFerror = DFE_BADCALL;
  1103.         return(-1);
  1104.     }
  1105.  
  1106.     if (!(dfile->up_access & DFACC_READ)) {
  1107.         DFerror = DFE_BADACC;
  1108.         return(-1);
  1109.     }
  1110.  
  1111.     if (offset > dfile->up_dd->length) {
  1112.         offset = dfile->up_dd->length;
  1113.         DFerror = DFE_BADSEEK;
  1114.     }
  1115.  
  1116.     CKSEEK( dfile->file, (long) dfile->up_dd->offset + offset, 0, -1);
  1117.     return(offset);
  1118. }
  1119.  
  1120.  
  1121. /*-----------------------------------------------------------------------------
  1122.  * Name:    DFwrite
  1123.  * Purpose: write bytes to DF file (part of element specified by DFaccess)
  1124.  * Inputs:  dfile: pointer to open DF file
  1125.  *          ptr: pointer to data to be written
  1126.  *          len: number of bytes to written
  1127.  * Returns: number of bytes written on success, -1 on failure
  1128.  * Invokes: DFIcheck
  1129.  * Users:   HDF programmers, DFputelement
  1130.  *---------------------------------------------------------------------------*/
  1131.  
  1132. int32 DFwrite( dfile, ptr, len)
  1133. DF *dfile;
  1134. char *ptr;
  1135. int32 len;
  1136. {
  1137. #ifdef VMS
  1138.     int32 totalwritten;
  1139.     int32 writesize;
  1140. #endif /*VMS*/
  1141.  
  1142.     DFerror = DFE_NOERROR;
  1143.  
  1144.     if (DFIcheck(dfile) )
  1145.         return( -1);
  1146.  
  1147.     if (!(dfile->up_dd)) {
  1148.         DFerror = DFE_BADCALL;
  1149.         return(-1);
  1150.     }
  1151.  
  1152.     if (!(dfile->up_access & DFACC_WRITE)) {
  1153.         DFerror = DFE_RDONLY;
  1154.         return(-1);
  1155.     }
  1156.  
  1157.     if (!ptr) {
  1158.         DFerror = DFE_BADPTR;
  1159.         return(-1);
  1160.     }
  1161.  
  1162.     if (len<0) {
  1163.         DFerror = DFE_BADLEN;
  1164.         return(-1);
  1165.     }
  1166.  
  1167.     if (!(dfile->changed)) {        /* if an update between writes, re-seek */
  1168.       CKSEEK( dfile->file, (long) dfile->up_dd->offset + dfile->up_dd->length,
  1169.             0, -1);
  1170.     }
  1171.  
  1172. #ifdef VMS
  1173.     totalwritten = 0;
  1174.     while (totalwritten<len) {
  1175.         writesize = len - totalwritten;
  1176.         if (writesize>512) writesize = 512; /* write at most 512 at a time */
  1177.         CKWRITE( &ptr[totalwritten], (int)writesize, 1, dfile->file, -1); 
  1178.         totalwritten += writesize;
  1179.     }
  1180. #else /*VMS*/
  1181.     if (len) { CKWRITE( ptr, len, 1, dfile->file, -1); }
  1182. #endif /*VMS*/
  1183.     dfile->up_dd->length += len;
  1184.     return(len);
  1185. }
  1186.  
  1187.  
  1188. /*-----------------------------------------------------------------------------
  1189.  * Name:    DFupdate
  1190.  * Purpose: write out updated DD blocks to file
  1191.  * Inputs:  dfile: pointer to open DF file
  1192.  * Returns: 0 on success, -1 on failure
  1193.  * Invokes: DFIcheck
  1194.  * Users:   HDF programmers
  1195.  *---------------------------------------------------------------------------*/
  1196.  
  1197. int DFupdate( dfile)
  1198. DF *dfile;
  1199. {
  1200.     DFdle *prev, *current;
  1201.     int i;
  1202.  
  1203.     DFerror = DFE_NOERROR;
  1204.  
  1205.     if ( DFIcheck(dfile))
  1206.         return(-1);
  1207.  
  1208.     if (dfile->type!=1) {
  1209.         DFerror= DFE_NOTOPEN;
  1210.         return(-1);
  1211.     }
  1212.  
  1213.     prev=dfile->list;           /* start of DLE list */
  1214.  
  1215.     if (dfile->changed) {           /* modified */
  1216.         while (current=prev->next) {
  1217.             CKSEEK( dfile->file, (long) prev->ddh.next,0, -1);
  1218.             if (current->ddh.dds) {
  1219. #ifdef DF_STRUCTOK
  1220.                 CKWRITE( ¤t->ddh, sizeof(DFddh) +
  1221.                     (current->ddh.dds*sizeof(DFdd)), 1, dfile->file, -1);
  1222. #else /*DF_STRUCTOK*/
  1223.                 {
  1224.                     register  char *p;
  1225.                     p = DFtbuf;
  1226.                     INT16WRITE( p, current->ddh.dds);
  1227.                     INT32WRITE( p, current->ddh.next);
  1228.                     for (i=0; i<current->ddh.dds; i++) {
  1229.                         UINT16WRITE( p, current->dd[i].tag);
  1230.                         UINT16WRITE( p, current->dd[i].ref);
  1231.                         INT32WRITE( p, current->dd[i].offset);
  1232.                         INT32WRITE( p, current->dd[i].length);
  1233.                     }
  1234.                     CKWRITE( DFtbuf, 6+i*12, 1, dfile->file, -1);
  1235.                         /* 6= size of DDH, 12=size of DD */
  1236.                 }
  1237. #endif /*DF_STRUCTOK*/
  1238.             }
  1239.             prev=current;
  1240.         }
  1241.         DF_FLUSH(dfile->file);              /* ensure everything is written */
  1242.     }
  1243.     dfile->changed=0;
  1244.     return(0);
  1245. }   
  1246.  
  1247.  
  1248. /*-----------------------------------------------------------------------------
  1249.  * Name:    DFstat
  1250.  * Purpose: provide status information about DF file
  1251.  * Inputs:  dfile: pointer to open DF file
  1252.  *          dfinfo: ptr to space where to place information on HDF file
  1253.  * Returns: 0 on success, -1 on failure
  1254.  * Invokes: DFIcheck
  1255.  * Users:   HDF programmers
  1256.  *---------------------------------------------------------------------------*/
  1257.  
  1258. int DFstat(dfile, dfinfo)
  1259. DF *dfile;
  1260. struct DFdata *dfinfo;
  1261. {
  1262.  
  1263.     DFerror = DFE_NOERROR;
  1264.  
  1265.     if (DFIcheck(dfile) )
  1266.         return( -1);
  1267.  
  1268.         /* This is version number of program.  More will be added later */
  1269.     dfinfo->version = DFVERSION;
  1270.     return(0);
  1271. }
  1272.     
  1273.  
  1274. /*-----------------------------------------------------------------------------
  1275.  * Name:    DFgetelement
  1276.  * Purpose: read a data element from df file
  1277.  * Inputs:  dfile: pointer to open DF file
  1278.  *          tag, ref: id of data element
  1279.  *          ptr: space to put data element in
  1280.  * Returns: number of bytes read on success, -1 on failure
  1281.  * Invokes: DFaccess, DFread
  1282.  * Users:   HDF programmers, utilities, many other routines
  1283.  *---------------------------------------------------------------------------*/
  1284.  
  1285. int32 DFgetelement( dfile, tag, ref, ptr)
  1286. DF *dfile;
  1287. uint16 tag, ref;
  1288. char *ptr;
  1289. {
  1290.     if ( DFaccess( dfile, tag, ref, "r")<0) return((int32) -1);
  1291.     return( DFread( dfile, ptr, (int32) dfile->up_dd->length));
  1292. }
  1293.  
  1294.  
  1295. /*-----------------------------------------------------------------------------
  1296.  * Name:    DFputelement
  1297.  * Purpose: write a data element to df file
  1298.  * Inputs:  dfile: pointer to open DF file
  1299.  *          tag, ref: id of data element
  1300.  *          ptr: pointer to data element to be written
  1301.  *          len: length of data element
  1302.  * Returns: 0 on success, -1 on failure
  1303.  * Invokes: DFaccess, DFwrite
  1304.  * Users:   HDF programmers, utilities, many other routines
  1305.  *---------------------------------------------------------------------------*/
  1306.  
  1307. int DFputelement( dfile, tag, ref, ptr, len)
  1308. DF *dfile;
  1309. uint16 tag, ref;
  1310.  char *ptr;
  1311. int32 len;
  1312. {
  1313.     if ( DFaccess( dfile, tag, ref, "w")<0) return(-1);
  1314.     if( DFwrite( dfile, ptr, len)<0) return(-1);
  1315.     return(0);
  1316. }
  1317.  
  1318.  
  1319. /*-----------------------------------------------------------------------------
  1320.  * Name:    DFdup
  1321.  * Purpose: Add a new tag/ref for existing data
  1322.  * Inputs:  dfile: pointer to open DF file
  1323.  *          itag, iref: new id of data element
  1324.  *          otag, oref: current id of data element
  1325.  * Returns: 0 on success, -1 on failure
  1326.  * Invokes: DFIcheck, DFIfind, DFIemptyDD
  1327.  * Users:   HDF programmers, utilities, many other routines
  1328.  *---------------------------------------------------------------------------*/
  1329.  
  1330. int DFdup(dfile, itag, iref, otag, oref)
  1331. DF *dfile;
  1332. uint16 itag, iref, otag, oref;  /* new, existing tag/refs */
  1333. {
  1334.     DFdle *odlep, *idlep;
  1335.     int ocdd, icdd;
  1336.     DFdd *newdd;
  1337.  
  1338.     DFerror = DFE_NOERROR;
  1339.  
  1340.     if (DFIcheck(dfile) )
  1341.         return( -1);
  1342.  
  1343.     if (DFIfind( dfile, otag, oref, 1, 0, 0, &odlep, &ocdd)<0) {
  1344.         DFerror = DFE_NOMATCH;      /* existing tag/ref does not exist! */
  1345.         return(-1);
  1346.     }
  1347.  
  1348.     if (!DFIfind( dfile, itag, iref, 1, 0, 0, &idlep, &icdd))
  1349.         newdd = &idlep->dd[icdd];   /* replaces existing DD */
  1350.     else {
  1351.         newdd = DFIemptyDD(dfile);  /* find empty DD */
  1352.         if (!newdd) return(-1);
  1353.         newdd->tag = itag;
  1354.         newdd->ref = iref;
  1355.  
  1356.         if (DFmaxref < iref) DFmaxref = iref;       /* mark iref as used */
  1357.         if (DFreflist) DFreflist[iref/8] |= patterns[iref%8];
  1358.     }
  1359.     newdd->offset = odlep->dd[ocdd].offset;
  1360.     newdd->length = odlep->dd[ocdd].length;
  1361.     dfile->changed = 1;
  1362.     return(0);
  1363. }
  1364.  
  1365.  
  1366. /*-----------------------------------------------------------------------------
  1367.  * Name:    DFdel
  1368.  * Purpose: Delete a data element from file
  1369.  * Inputs:  dfile: pointer to open DF file
  1370.  *          tag, ref: id of data element
  1371.  * Returns: 0 on success, -1 on failure
  1372.  * Invokes: DFIcheck, DFIfind
  1373.  * Users:   HDF programmers, utilities, many other routines
  1374.  * Remarks: Data element is not deleted, only the reference to it is changed
  1375.  *---------------------------------------------------------------------------*/
  1376.  
  1377. int DFdel(dfile, tag, ref)
  1378. DF *dfile;
  1379. uint16 tag, ref;
  1380. {
  1381.     DFdle *dlep;
  1382.     int cdd;
  1383.  
  1384.     DFerror = DFE_NOERROR;
  1385.  
  1386.     if (DFIcheck(dfile) )
  1387.         return( -1);
  1388.  
  1389.     if (DFIfind( dfile, tag, ref, 1, 0, 0, &dlep, &cdd)<0) {
  1390.         DFerror = DFE_NOMATCH;      /* nothing to delete */
  1391.         return(-1);
  1392.     }
  1393.     dlep->dd[cdd].tag = DFTAG_NULL;
  1394.     dlep->dd[cdd].ref = 0;
  1395.     dfile->changed = 1;
  1396.     return(0);
  1397. }
  1398.  
  1399.  
  1400. /*-----------------------------------------------------------------------------
  1401.  * Name:    DFnewref
  1402.  * Purpose: Get an ununsed reference number
  1403.  * Inputs:  dfile: pointer to HDF file
  1404.  *          tag: tag for which ref is needed
  1405.  * Returns: unused ref number if found.  0 with DFerror set if not.
  1406.  * Users:   HDF programmers, for adding data elements
  1407.  * Invokes: DFIcheck
  1408.  * Remarks: Currently, returns a ref which is not used with any tag, except
  1409.  *          possibly DFTAG_MT
  1410.  *---------------------------------------------------------------------------*/
  1411.  
  1412. uint16 DFnewref(dfile)
  1413. DF *dfile;
  1414. {
  1415.     DFdle *DLEp;
  1416.     int i,j;
  1417.  
  1418.     DFerror = DFE_NOERROR;
  1419.  
  1420.     if (DFIcheck(dfile) )
  1421.         return ((uint16) 0);
  1422.  
  1423.     if (DFmaxref < 65535)       /* 65535 = largest 16-bit uint = largest ref */
  1424.         return(++DFmaxref);
  1425.  
  1426.     /* allocate a bit array of 65536 bits - one for each ref */
  1427.     if (DFreflist==NULL) {
  1428.         if ((DFreflist = (unsigned char *) DFIgetspace(8192)) == NULL)
  1429.                 return((uint16) 0);             /* 8192 = 65536/8 */
  1430.         
  1431.         for (i=1; i<8192; i++) DFreflist[i] = 0;    /* initialize */
  1432.         DFreflist[0] = 0x80;            /* ref 0 is not to be allocated */
  1433.  
  1434.         for (DLEp=dfile->list; DLEp; DLEp=DLEp->next) /* go through all DDs */
  1435.             for (i=0; i<DLEp->ddh.dds; i++)
  1436.                 if (DLEp->dd[i].tag != DFTAG_MT)    /* set ref'th bit to 1 */
  1437.                     DFreflist[DLEp->dd[i].ref/8] |=
  1438.             patterns[DLEp->dd[i].ref%8];
  1439.     }
  1440.  
  1441.     for (i=0; i<8192; i++)
  1442.         if (DFreflist[i] != 0xff) break; /* if ff, all refs taken */
  1443.  
  1444.     if (i==8192) {
  1445.         DFerror = DFE_NOREF;
  1446.         return((uint16) 0);
  1447.     }
  1448.  
  1449.     for (j=0; j<8; j++) {
  1450.         if (!(DFreflist[i] & patterns[j])) { /* ref j is not allocated */
  1451.             DFreflist[i] |= patterns[j]; /* ref j is now in use */
  1452.             return((uint16) (i*8 + j));    /* ref to use */
  1453.         }
  1454.     }
  1455.  
  1456.     return((uint16) 0);        /* this statement should not be reached */
  1457. }
  1458.  
  1459.  
  1460. /*-----------------------------------------------------------------------------
  1461.  * Name:    DFishdf
  1462.  * Purpose: Is this an HDF file?
  1463.  * Inputs:  filename: name of HDF file
  1464.  * Returns: 0 if it is an HDF file, -1 if not.  DFerror is set to open error
  1465.  *              if any, else to DFE_NOERROR
  1466.  * Users:   HDF systems programmers, for checking files
  1467.  * Invokes: DFopen, DFclose
  1468.  * Remarks: none
  1469.  *---------------------------------------------------------------------------*/
  1470.  
  1471. DFishdf(filename)
  1472. char *filename;
  1473. {
  1474.     DF *dfile;
  1475.  
  1476.     DFerror = DFE_NOERROR;
  1477.  
  1478.     dfile = DFopen(filename, DFACC_READ, -1);
  1479.     if (dfile==NULL) return(-1);
  1480.     return(DFclose(dfile));
  1481. }
  1482.  
  1483.  
  1484. /*-----------------------------------------------------------------------------
  1485.  * Name:    DFerrno
  1486.  * Purpose: return value of DFerror
  1487.  * Inputs:  none
  1488.  * Returns: value of DFerror
  1489.  * Users:   HDF users, programmers
  1490.  * Invokes: none
  1491.  * Remarks: none
  1492.  *---------------------------------------------------------------------------*/
  1493.  
  1494. int DFerrno()
  1495. {
  1496.  
  1497.     return(DFerror);
  1498. }
  1499.  
  1500.  
  1501. /*-----------------------------------------------------------------------------
  1502.  * Name:    DFIerr
  1503.  * Purpose: Close a file and return on error. save DFerror
  1504.  * Inputs:  dfile: pointer to HDF file to close
  1505.  * Returns: -1
  1506.  * Users:   HDF systems programmers, for error handling
  1507.  * Invokes: DFclose
  1508.  * Remarks: Used to centralize some error handling
  1509.  *---------------------------------------------------------------------------*/
  1510.  
  1511. int DFIerr(dfile)
  1512. DF *dfile;
  1513. {
  1514.     int saveerror;
  1515.  
  1516.     saveerror = DFerror;
  1517.     if (dfile!=NULL) (void) DFclose(dfile);
  1518.     DFerror = saveerror;
  1519.     return(-1);
  1520. }
  1521.